package handlers

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"regexp"
	"strconv"
	"strings"
	"time"
	"werewolf/core"

	_ "github.com/go-sql-driver/mysql"
)

var count int = 0

// Conversation 存储对话信息
type Conversation struct {
	MessageID int    `json:"message_id"`
	RoomID    int    `json:"room_id"`
	Role      string `json:"role"`
	Message   string `json:"message"`
}

// KimiAPIResponse 用于解析 API 返回的 JSON 数据
type KimiAPIResponse struct {
	Usage struct {
		PromptTokens     int `json:"prompt_tokens"`
		CompletionTokens int `json:"completion_tokens"`
		TotalTokens      int `json:"total_tokens"`
	} `json:"usage"`
	Choices []struct {
		Message struct {
			Content string `json:"content"`
		} `json:"message"`
	} `json:"choices"`
}


// CallKimiAPI 发送请求到 Kimi API 并返回响应
func CallKimiAPI(apiKey string, messages []map[string]string) (*KimiAPIResponse, error) {
	time.Sleep(2 * time.Second) //延时
	url := "https://api.moonshot.cn/v1/chat/completions"
	requestBody := map[string]interface{}{
		"model":      "moonshot-v1-32k",
		"messages":   messages,
		"max_tokens": 120,
	}
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var apiResponse KimiAPIResponse
	err = json.Unmarshal(body, &apiResponse)
	if err != nil {
		return nil, err
	}

	return &apiResponse, nil
}

func NameList(roletype int, roomno int) []int {
	//在此函数中查询当ai扮演各个角色时可以使用的对象
	handle, err := core.Connection()
	if err != nil {
		return nil //连接出错，直接返回
	}
	//该房间的角色列表
	var wn0, fn0, setroles = 0, 0, ""
	err = handle.QueryRow("SELECT Role,Werewolf,Folk FROM game WHERE RmNo =?", roomno).Scan(&setroles, &wn0, &fn0)
	if err != nil {
		return nil //查询角色列表出错
	}
	var roles []string
	if setroles != "" {
		roles = strings.Split(setroles, ";")
	}

	for i := 0; i < wn0; i++ {
		roles = append(roles, "w")
	}
	for i := 0; i < fn0; i++ {
		roles = append(roles, "f")
	} //加入普通狼和平民
	var namelist []int = make([]int, 0)
	rows, err := handle.Query("SELECT Role,No,Survival FROM player WHERE RmNo =?", roomno)
	if err != nil {
		return nil //查询玩家列表出错
	}
	if roletype == 1 {
		//返回可供狼人击杀的对象列表，将当前房间不是狼人、恶魔、狼王玩家且目前正在存活的玩家加入列表
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "w" && roles[role-1] != "w-king" && roles[role-1] != "w-devil" && survival == 1 {
				//加入可击杀列表
				namelist = append(namelist, no)
			}
		}
	} else if roletype == 2 {
		//返回女巫可以毒杀的列表（除了女巫本身以及已经死亡的玩家）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "g-witch" && survival == 1 {
				namelist = append(namelist, no)

			}
		}
		//返回可供女巫施毒的对象列表
	} else if roletype == 3 {
		//返回预言家可以查验的玩家列表（除了预言家本身以及已经死亡的玩家）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "g-seer" && survival == 1 {
				namelist = append(namelist, no)

			}
		}
	} else if roletype == 4 {
		//返回猎人死亡时可以选择杀死的对象（目前仍然存活的玩家除了自己本身）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "g-hunter" && survival == 1 {
				//加入可击杀列表
				namelist = append(namelist, no)
			}
		}
	} else if roletype == 5 {
		//返回狼王死亡时可以选择杀死的对象（目前仍然存活的玩家除了自己本身）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "w-king" && survival == 1 {
				//加入可击杀列表
				namelist = append(namelist, no)
			}
		}
	} else if roletype == 6 {
		//返回骑士可以决斗的对象列表（目前仍然存活的玩家除了自己本身）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "g-knight" && survival == 1 {
				//加入可击杀列表
				namelist = append(namelist, no)
			}
		}
	} else if roletype == 7 {
		//返回守卫可以守护的对象列表（目前仍然存活的玩家除了自己本身）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "g-guard" && survival == 1 {
				//加入可击杀列表
				namelist = append(namelist, no)
			}
		}
	} else if roletype == 8 {
		//返回恶魔可以查验的对象列表（目前仍然存活的玩家除了自己本身和其他狼人阵营的玩家）
		for rows.Next() {
			var no int
			var role int
			var survival int
			if err := rows.Scan(&role, &no, &survival); err != nil {
				return nil //查询玩家列表出错
			}
			if roles[role-1] != "w-devil" && roles[role-1] != "w" && roles[role-1] != "w-king" && roles[role-1] != "w-knight" && survival == 1 {
				//加入可击杀列表
				namelist = append(namelist, no)
			}
		}
	}
	return namelist
}

// getConversationsByRoomID 检索指定房间ID的对话历史
func getConversationsByRoomID(roomID int) ([]Conversation, error) {
	db, err := core.Connection()
	if err != nil {
		fmt.Println("Error connecting to database")
		return nil, err
	}
	var conversations []Conversation
	rows, err := db.Query("SELECT message_id, room_id, role, message FROM message WHERE room_id = ? ORDER BY message_id ASC", roomID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	defer db.Close()
	for rows.Next() {
		var conv Conversation
		err := rows.Scan(&conv.MessageID, &conv.RoomID, &conv.Role, &conv.Message)
		if err != nil {
			return nil, err
		}
		conversations = append(conversations, conv)
	}
	return conversations, nil
}

// insertConversation 插入新的对话记录到数据库
func insertConversation(conv Conversation) error {
	times := 0
	times++
	db, err := core.Connection()
	if err != nil {
		fmt.Println("Error connecting to database")
		return err
	}
	if db == nil {
		return fmt.Errorf("error connecting to database")
	}
	stmt, err := db.Prepare("INSERT INTO message (room_id, role, message) VALUES (?, ?, ?)")
	if err != nil {
		return err
	}
	defer stmt.Close()
	defer db.Close()
	_, err = stmt.Exec(conv.RoomID, conv.Role, conv.Message)
	return err
}

func talkToKimi(RoomID int, message string) (*KimiAPIResponse, error) {
	apiKey := "sk-fHBc0nQMrVo6b4ZqzzeEzl1Pv5COoGEWMv9EBi8ooAW9xeF4"
	var err error
	//插入系统新的发言进入数据库
	newConvo := Conversation{
		RoomID:  RoomID,
		Role:    "system",
		Message: message,
	}
	err = insertConversation(newConvo) //向数据库插入新的回复
	if err != nil {
		fmt.Println("Error inserting conversation:", err)
		return nil, err
	}
	history, err := getConversationsByRoomID(RoomID)
	if err != nil {
		fmt.Println("Error getting conversations:", err)
		return nil, err
	}

	apiMessages := make([]map[string]string, 0, len(history))
	for _, conv := range history {
		apiMessages = append(apiMessages, map[string]string{
			"role":    conv.Role,
			"content": conv.Message,
		})
	} //读取历史信息
	count++
	response, err := CallKimiAPI(apiKey, apiMessages) //传入[]map，包含历史信息和新加入的信息
	if err != nil {
		fmt.Println("Error calling API:", err)
		return nil, err
	}
	if len(response.Choices) == 0 {
		err = fmt.Errorf("no choices returned from API") //使用 err.Error() ==匹配错误字符串。
		return nil, err
	}
	kimiMessage := response.Choices[0].Message.Content //读入kimi的回复
	newConvo = Conversation{
		RoomID:  RoomID,
		Role:    "assistant",
		Message: kimiMessage,
	}
	err = insertConversation(newConvo) //向数据库插入新的回复
	if err != nil {
		fmt.Println("Error inserting conversation:", err)
		return nil, err
	}

	return response, nil
} //传入要发送的指令，完成对数据库的检索和对kimi的调用

//信息告知函数会返回一个bool值，true表示信息发送成功，false表示信息发送失败。

func gamePreparation(RoomID int, TotalNumber int, Civilian int, Werewolf int, Seer int, Witch int, Guard int, Hunter int, Knight int, WolveKing int, Devil int, WolveKnight int) bool {
	text2 := `现在，你将扮演狼人杀游戏中的一个角色，陪伴人类玩家进行狼人杀游戏，请严格按照系统给出的引导输出你的发言和操作：
	游戏规则：
	游戏人数：n
	狼人数量：n
	平民数量：n
	预言家数量：n
	女巫数量：n
	狼王数量：n
	恶魔数量：n
	猎人数量：n
	守卫数量：n
	骑士数量：n
	恶灵骑士数量：n
	获胜条件：狼人阵营角色数量≥其他角色数量 / 其他角色淘汰所有狼人角色
	角色说明：
	狼人：狼人阵营，夜晚行动，必须决定杀死某一位玩家。
	狼王：狼人阵营，可以在夜晚查验好人阵营的角色是平民还是神职。
	恶魔：狼人阵营，可以在夜晚。
	恶灵骑士：狼人阵营，在被预言家查验以及女巫毒杀后时，会导致对方死亡。
	平民：好人阵营，无特殊技能，需通过逻辑推理和讨论找出狼人。
	猎人：好人阵营，可以在被淘汰时选择杀死一名玩家。
	守卫：好人阵营，每晚必须守护一名玩家（不能连续每晚守护同一名玩家），使其免受狼人伤害。
	骑士：好人阵营，可以对一名玩家发出决斗，若该玩家是好人阵营，则骑士出局，若该玩家是狼人，则该玩家出局。
	预言家：好人阵营，每晚可查验一名玩家身份。
	女巫：好人阵营，拥有解药和毒药，可以在夜晚解救被狼人杀害的玩家以及毒杀某一名玩家。
	发言提示：在轮到你发言时尽可能简短地发言，根据实际情况尝试模仿普通玩家的语气，尝试使用狼人杀专业术语（如：刀、金水、银水、跳、查杀、铁等等）。
	投票提示，每一轮投票后都会告知你结果，如果没有结果告知 ，视为平票
	理解请回复：“明白。”`
	//在此加入简短的解释规则
	// 创建正则表达式，匹配游戏规则中的人数n
	re := regexp.MustCompile(`(游戏人数：|狼人数量：|平民数量：|预言家数量：|女巫数量：|狼王数量：|恶魔数量：|猎人数量：|守卫数量：|骑士数量：)n`)
	// 替换函数，根据不同的前缀返回不同的数字
	replaceFunc := func(match string) string {
		switch match {
		case "游戏人数：n":
			return "游戏人数：" + strconv.Itoa(TotalNumber)
		case "平民数量：n":
			return "平民数量：" + strconv.Itoa(Civilian)
		case "狼人数量：n":
			return "狼人数量：" + strconv.Itoa(Werewolf)
		case "预言家数量：n":
			return "预言家数量：" + strconv.Itoa(Seer)
		case "女巫数量：n":
			return "女巫数量：" + strconv.Itoa(Witch)
		case "狼王数量：n":
			return "狼王数量：" + strconv.Itoa(WolveKing)
		case "恶魔数量：n":
			return "恶魔数量：" + strconv.Itoa(Devil)
		case "猎人数量：n":
			return "猎人数量：" + strconv.Itoa(Hunter)
		case "守卫数量：n":
			return "守卫数量：" + strconv.Itoa(Guard)
		case "骑士数量：n":
			return "骑士数量：" + strconv.Itoa(Knight)
		case "恶灵骑士数量：n":
			return "恶灵骑士数量：" + strconv.Itoa(WolveKnight)
		default:
			return match
		}
	}

	// 使用ReplaceAllStringFunc进行替换
	newText := re.ReplaceAllStringFunc(text2, replaceFunc)

	response, err := talkToKimi(RoomID, newText)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}

} //为ai进行规则解读，输入游戏的人数

func gameStart(RoomID int, Role string, Number int) bool {
	text := "角色分配：游戏开始，你的角色是" + Role + "，号码是" + strconv.Itoa(Number) + "。"
	text2 := text + "理解回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //为ai分配角色和号码并通知ai开始游戏

func wolfTeammateInformed(RoomID int, Number []int) bool {
	text := "狼人队友信息：你的狼人队友为"
	if Number[0] == -1 {
		text = "这局游戏只有你一个狼人。"
	} else {
		for i := 0; i < len(Number); i++ {
			if i != 0 {
				text += "和"
			}
			text += strconv.Itoa(Number[i]) + "号"
		}
	}
	text += "。"
	text2 := text + "理解回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //告知ai狼队友的号码

// func dawnInformed(RoomID int) bool {
// 	fmt.Println("正在进入：dawnInformed")
// 	text := "天亮了。"
// 	text2 := text + "理解回复：“明白。”"
// 	response, err := talkToKimi(RoomID, text2)
// 	if err != nil {
// 		fmt.Println("Error calling API:", err)
// 		return false
// 	}
// 	if response.Choices[0].Message.Content == "明白。" {
// 		return true
// 	} else {
// 		return false
// 	}
// } //告知ai天亮了，返回bool表示通知是否成功

// func getDarkInformed(RoomID int) bool {
// 	fmt.Println("正在进入：getDarkInformed")
// 	text := "天黑了。"
// 	text2 := text + "理解回复：“明白。”"
// 	response, err := talkToKimi(RoomID, text2)
// 	if err != nil {
// 		fmt.Println("Error calling API:", err)
// 		return false
// 	}
// 	if response.Choices[0].Message.Content == "明白。" {
// 		return true
// 	} else {
// 		return false
// 	}
// } //告知ai现在是黑夜，返回bool表示通知是否成功

func deathInformed(RoomID int, death string) bool {
	text := "死亡信息：昨晚死亡的玩家号码为:"
	if death == "" {
		text = "昨晚是平安夜。"
	} else {
		text = death
	}
	text += "。"
	text2 := text + "理解回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //告知ai昨晚死亡的玩家的号码

func vote(RoomID int) int {
	text := "请选择投票出局的玩家"
	text2 := text + "回复格式：投给n号"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	// 创建正则表达式，匹配“投给n号”中的数字n
	re := regexp.MustCompile(`投给(\d+)号`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1
		}
		return number
	} else {
		return -1
	}
}

func votedOutInformed(RoomID int, Number int) bool {
	text := "投票信息：\n"
	if Number == -1 {
		text = "本轮平票，进行下一轮投票。"
	} else if Number == -2 {
		text = "本轮投票再次平票，不再进行下一轮投票，游戏继续"
	} else {
		text = "投票结束，被淘汰出局的玩家号码为" + strconv.Itoa(Number) + "号。"
	}
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //告知ai投票出局的玩家的号码

func otherPlayersStatements(RoomID int, Statements map[int]string) bool {
	text := "其他玩家发言信息：\n"
	for id, statement := range Statements {
		text += strconv.Itoa(id) + "号玩家发言：" + statement + "\n"
	}
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
	// }

} //告知ai其他玩家的发言,重复调用两次，将发言在ai前和ai后的玩家分开来

func otherPlayersLastWords(RoomID int, id int, statement string) bool {
	text := "有玩家被淘汰，他的遗言是：\n"
	text += strconv.Itoa(id) + "号玩家发言：" + statement + "\n"
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
	// }

}

func votedInformed(RoomID int, Vote map[int]int) bool {
	text := "投票信息：\n"
	for id, vote := range Vote {
		text += strconv.Itoa(id) + "号玩家投票给" + strconv.Itoa(vote) + "号。\n"
	}
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}

	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //告知ai每个玩家投票的结果

func werewolfTeammateSpeaks(RoomID int, Statements map[int]string) string {
	text := "狼人队友夜晚发言："
	for id, statement := range Statements {
		text += strconv.Itoa(id) + "号狼队友：" + statement + "。"
	}
	text += "回复你的发言与狼队友商讨要杀的玩家，回复格式：夜晚发言：******"
	response, err := talkToKimi(RoomID, text)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return "error"
	}

	if strings.Contains(response.Choices[0].Message.Content, "夜晚发言：") {
		return response.Choices[0].Message.Content
	} else {
		return "error"
	}
} //输入狼队友的发言，令ai返回回复进行讨论

func werewolvesKill(RoomID int, Number int, namelist []int) int {
	if Number == 1 {
		text := "现在是夜晚，请选择要杀的人。"
		text1 := "你可以选择的名单为："
		for i := 0; i < len(namelist); i++ {
			text1 += strconv.Itoa(namelist[i]) + "号"
			if i != len(namelist)-1 {
				text1 += "、"
			}
		}
		text2 := text + text1 + "回复格式：杀死n号"
		response, err := talkToKimi(RoomID, text2)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return -1
		}
		// 创建正则表达式，匹配“杀死n号”中的数字n
		re := regexp.MustCompile(`杀死(\d+)号`)
		// 使用FindStringSubmatch方法查找匹配项
		matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
		//分解
		if len(matches) > 1 {
			// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
			number, err := strconv.Atoi(matches[1])
			if err != nil {
				fmt.Println("Error converting string to int:", err)
				return -1
			} else {
				return number
			}
		} else {
			return -1
		}
		//正常执行询问杀人流程
	} else if Number == 2 {
		//号码选择错误，重新选择
		text := "根据规则，你不能杀死这个玩家，请重新选择要杀的人。"
		text1 := "你可以选择的名单为："
		for i := 0; i < len(namelist); i++ {
			text1 += strconv.Itoa(namelist[i]) + "号"
			if i != len(namelist)-1 {
				text1 += "、"
			}
		}
		text2 := text + text1 + "回复格式：杀死n号"
		response, err := talkToKimi(RoomID, text2)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return -1
		}
		// 创建正则表达式，匹配“杀死n号”中的数字n
		re := regexp.MustCompile(`杀死(\d+)号`)
		// 使用FindStringSubmatch方法查找匹配项
		matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
		//分解
		if len(matches) > 1 {
			// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
			number, err := strconv.Atoi(matches[1])
			if err != nil {
				fmt.Println("Error converting string to int:", err)
				return -1
			}
			return number
		} else {
			return -1
		}
	}
	return 0 //正常执行流程
}

//改为夜晚只有或者只剩下ai一个狼人时，ai会选择杀死的玩家，否则需要前端选择

func seerVerification(RoomID int, namelist []int) int {
	text := "你是预言家，请选择查验的玩家？"
	text1 := "你可以选择的名单为："
	for i := 0; i < len(namelist); i++ {
		text1 += strconv.Itoa(namelist[i]) + "号"
		if i != len(namelist)-1 {
			text1 += "、"
		}
	}
	text2 := text + text1 + "回复格式：查验n号"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	// 创建正则表达式，匹配“杀死n号”中的数字n
	re := regexp.MustCompile(`查验(\d+)号`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1
		}
		return number
	} else {
		return -1
	}
} //返回正整数表示要查验的玩家号码,-1表示出错
//让ai选择要杀的玩家的号码,返回被杀的玩家的号码
//选择错误号码之后的处理？

func seerVerificationInformed(RoomID int, Number int, Role string) bool { //传入查验玩家的号码和角色
	text := "预言家查验信息：" + strconv.Itoa(Number) + "号玩家的身份是" + Role + "。"
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //查验结果告知

func devilVerification(RoomID int, namelist []int) int {
	text := "你是恶魔可以查验一个平民阵营玩家是否为神职，请选择查验的玩家"
	text1 := "你可以选择的名单为："
	for i := 0; i < len(namelist); i++ {
		text1 += strconv.Itoa(namelist[i]) + "号"
		if i != len(namelist)-1 {
			text1 += "、"
		}
	}
	text2 := text + text1 + "回复格式：查验n号"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	// 创建正则表达式，匹配“杀死n号”中的数字n
	re := regexp.MustCompile(`查验(\d+)号`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1
		}
		return number
	} else {
		return -1
	}
}

func devilVerificationInformed(RoomID int, Number int, Role string) bool { //传入查验玩家的号码和角色
	text := "恶魔查验信息：" + strconv.Itoa(Number) + "号玩家的身份是" + Role + "。"
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
} //查验结果告知

func witchPoison(RoomID int, namelist []int) int {
	text := "女巫，是否使用毒药？"
	text1 := "你可以选择的名单为："
	for i := 0; i < len(namelist); i++ {
		text1 += strconv.Itoa(namelist[i]) + "号"
		if i != len(namelist)-1 {
			text1 += "、"
		}
	}
	text2 := text + text1 + "回复格式：不使用毒药。/对n号玩家使用毒药。"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	if response.Choices[0].Message.Content == "不使用毒药。" {
		return 0
	}
	// 创建正则表达式，匹配“对n号玩家使用毒药”中的数字n
	re := regexp.MustCompile(`对(\d+)号玩家使用毒药`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1 //转换出错
		}
		return number
	} else {
		return -1 //没有匹配
	}
} //询问女巫是否使用毒药，返回0表示不用，正整数表示要使用的玩家号码,-1表示出错

func witchAntidote(RoomID int, Killed int) int {
	if Killed == 1 {
		text := "狼人杀死了你，根据规则，你自动使用了唯一的解药，理解请回复：“明白。”"
		response, err := talkToKimi(RoomID, text)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return -1
		}
		if response.Choices[0].Message.Content == "明白。" {
			return 1 //使用解药
		} else {
			return 0 //选择错误，视为不使用解药
		}
		//狼人杀死了ai女巫，自动使用解药
	} else {
		text := "狼人杀死了" + strconv.Itoa(Killed) + "号玩家，是否使用唯一的解药？"
		text2 := text + "回复格式：使用。/不使用。"
		response, err := talkToKimi(RoomID, text2)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return -1
		}
		if response.Choices[0].Message.Content == "不使用。" {
			return 0
		} else if response.Choices[0].Message.Content == "使用。" {
			return 1
		} else {
			return -1 //选择错误
		}
	}

} //告知女巫被杀死的人的号码，让女巫选择是否使用解药,返回结果表示-1错误，0不使用，1使用

func speak(RoomID int) string {
	text := "轮到你发言，请简短发言，限制在20字以内。"
	text2 := text + "回复格式：发言：*******"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return ""
	}
	// 创建正则表达式，匹配“发言：”后的内容
	re := regexp.MustCompile(`发言：(.*)`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		return matches[1]
	} else {
		return ""
	}
}

func lastWords(RoomID int) string {
	text := "你已经出局，请简短发表遗言，限制在20字以内并尽量使用狼人杀术语。"
	text2 := text + "回复格式：发言：*******"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return ""
	}
	// 创建正则表达式，匹配“发言：”后的内容
	re := regexp.MustCompile(`发言：(.*)`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		return matches[1]
	} else {
		return ""
	}
}

// ai出局，进行遗言发表
func wolveKingKill(RoomID int, namelist []int) int {
	text := "你是狼王，被淘汰出局，可以使用技能杀死一人，请选择要杀的人。"
	text1 := "你可以选择的名单为："
	for i := 0; i < len(namelist); i++ {
		text1 += strconv.Itoa(namelist[i]) + "号"
		if i != len(namelist)-1 {
			text1 += "、"
		}
	}
	text2 := text + text1 + "回复格式：杀死n号。/不使用技能。"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	if response.Choices[0].Message.Content == "不使用技能。" {
		return 0
	} //不使用技能，返回0
	// 创建正则表达式，匹配“杀死n号”中的数字n
	re := regexp.MustCompile(`杀死(\d+)号`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1
		} else {
			return number
		}
	} else {
		return -1
	}
}

// ai出局，询问是否使用狼王技能,提供可供击杀列表
func hunterkill(RoomID int, namelist []int) int {
	text := "你是猎人，被淘汰出局，可以使用技能杀死一人，请选择要杀的人。"
	text1 := "你可以选择的名单为："
	for i := 0; i < len(namelist); i++ {
		text1 += strconv.Itoa(namelist[i]) + "号"
		if i != len(namelist)-1 {
			text1 += "、"
		}
	}
	text2 := text + text1 + "回复格式：杀死n号。/不使用技能。"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	if response.Choices[0].Message.Content == "不使用技能。" {
		return 0
	} //不使用技能，返回0
	// 创建正则表达式，匹配“杀死n号”中的数字n
	re := regexp.MustCompile(`杀死(\d+)号`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1
		} else {
			return number
		}
	} else {
		return -1
	}
}

func guardGuard(RoomID int, namelist []int, skilltype int, lastchoose int) int {
	if skilltype == 1 {
		text := "你是守卫，今晚可以使用技能守护一人，请选择要守护的人，请注意，你不能连续两晚守护同一个人。"
		text1 := "你可以选择的名单为："
		for i := 0; i < len(namelist); i++ {
			text1 += strconv.Itoa(namelist[i]) + "号"
			if i != len(namelist)-1 {
				text1 += "、"
			}
		}
		text2 := text + text1 + "回复格式：守护n号。"
		response, err := talkToKimi(RoomID, text2)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return -1
		}
		// 创建正则表达式，匹配“守护n号”中的数字n
		re := regexp.MustCompile(`守护(\d+)号`)
		// 使用FindStringSubmatch方法查找匹配项
		matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
		//分解
		if len(matches) > 1 {
			// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
			number, err := strconv.Atoi(matches[1])
			if err != nil {
				fmt.Println("Error converting string to int:", err)
				return -1
			} else {
				return number
			}
		} else {
			return -1
		}
	} else if skilltype == 2 {
		text := "你是守卫，你刚才重复选择了上一晚守护的玩家，请重新选择。"
		text1 := "你可以选择的名单为："
		for i := 0; i < len(namelist); i++ {
			if namelist[i] != lastchoose {
				text1 += strconv.Itoa(namelist[i]) + "号"
				if i != len(namelist)-1 {
					text1 += "、"
				}
			} //排除上一次的选择

		}
		text2 := text + text1 + "回复格式：守护n号。"
		response, err := talkToKimi(RoomID, text2)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return -1
		}
		// 创建正则表达式，匹配“守护n号”中的数字n
		re := regexp.MustCompile(`守护(\d+)号`)
		// 使用FindStringSubmatch方法查找匹配项
		matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
		//分解
		if len(matches) > 1 {
			// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
			number, err := strconv.Atoi(matches[1])
			if err != nil {
				fmt.Println("Error converting string to int:", err)
				return -1
			} else {
				return number
			}
		} else {
			return -1
		}
	}
	return -1
} //守卫选择需要守护的角色

// ai出局，询问是否使用猎人技能,提供可供击杀列表
func knightDuelistkill(RoomID int, namelist []int) int {
	text := "你是骑士，现阶段可以使用技能发起决斗，若与狼人阵营玩家决斗可以淘汰该玩家，若与平民阵营玩家决斗则你将被淘汰出局。"
	text1 := "你可以选择的名单为："
	for i := 0; i < len(namelist); i++ {
		text1 += strconv.Itoa(namelist[i]) + "号"
		if i != len(namelist)-1 {
			text1 += "、"
		}
	}
	text2 := text + text1 + "回复格式：与n号决斗。/不使用技能。"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return -1
	}
	if response.Choices[0].Message.Content == "不使用技能。" {
		return 0
	} //不使用技能，返回0
	// 创建正则表达式，匹配“守护n号”中的数字n
	re := regexp.MustCompile(`与(\d+)号决斗`)
	// 使用FindStringSubmatch方法查找匹配项
	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
	//分解
	if len(matches) > 1 {
		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
		number, err := strconv.Atoi(matches[1])
		if err != nil {
			fmt.Println("Error converting string to int:", err)
			return -1
		} else {
			return number
		}
	} else {
		return -1
	}
}

//骑士选择是否发起决斗,提供可供决斗列表

// func wolveKingVerification(RoomID int, namelist []int) int {
// 	fmt.Println("正在进入：wolveKingVerification")
// 	text := "你是狼王，请选择查验的玩家？"
// 	text1 := "你可以选择的名单为："
// 	for i := 0; i < len(namelist); i++ {
// 		text1 += strconv.Itoa(namelist[i]) + "号"
// 		if i != len(namelist)-1 {
// 			text1 += "、"
// 		}
// 	}
// 	text2 := text + text1 + "回复格式：查验n号"
// 	response, err := talkToKimi(RoomID, text2)
// 	if err != nil {
// 		fmt.Println("Error calling API:", err)
// 		return -1
// 	}
// 	// 创建正则表达式，匹配“杀死n号”中的数字n
// 	re := regexp.MustCompile(`查验(\d+)号`)
// 	// 使用FindStringSubmatch方法查找匹配项
// 	matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
// 	//分解
// 	if len(matches) > 1 {
// 		// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
// 		number, err := strconv.Atoi(matches[1])
// 		if err != nil {
// 			fmt.Println("Error converting string to int:", err)
// 			return -1
// 		}
// 		return number
// 	} else {
// 		return -1
// 	}
// }

var number_of_wolves_speka [100]int

func wolveTalk(RoomID int, wolvespeaker int, wolvespeak string, talktype int) string {
	if talktype == 1 {
		text := "现在是夜晚，根据情况和队友商讨狼人决策，轮到你发言，尽量简短，限制在20字以内："
		text1 := "回复格式：发言：*******"
		text2 := text + text1
		response, err := talkToKimi(RoomID, text2)
		if err != nil {
			fmt.Println("Error calling API:", err)
			return ""
		}
		// 创建正则表达式，匹配“发言：”后的内容
		re := regexp.MustCompile(`发言：(.*)`)
		// 使用FindStringSubmatch方法查找匹配项
		matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
		//分解
		if len(matches) > 1 {
			// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
			return matches[1]
		} else {
			return ""
		}
		//夜晚开场发言
	} else if talktype == 2 {
		if strings.Contains(wolvespeak, "1号") || strings.Contains(wolvespeak, "杀") || strings.Contains(wolvespeak, "刀") || strings.Contains(wolvespeak, "决定") {
			number_of_wolves_speka[RoomID-1]++
			number_of_wolves_speka[RoomID-1] %= 3
			text := "狼人队友发言："
			text += strconv.Itoa(wolvespeaker) + "号狼队友发言：" + wolvespeak + "\n"
			text1 := "现在是夜晚狼人商讨时间，请根据场上局势和此前的对话内容进行你的发言以商讨杀人决策，限制在20字以内：" + "回复格式：发言：*******"
			text2 := text + text1
			response, err := talkToKimi(RoomID, text2)
			if err != nil {
				fmt.Println("Error calling API:", err)
				return ""
			}
			// 创建正则表达式，匹配“发言：”后的内容
			re := regexp.MustCompile(`发言：(.*)`)
			// 使用FindStringSubmatch方法查找匹配项
			matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
			//分解
			if len(matches) > 1 {
				// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
				return matches[1]
			} else {
				return "error" //此处使用error字符串标识错误
			}
		} else if (number_of_wolves_speka[RoomID-1])%3 == 0 { //判断队友是否进行了两的倍数次发言
			number_of_wolves_speka[RoomID-1]++
			number_of_wolves_speka[RoomID-1] %= 3
			text := "狼人队友发言："
			text += strconv.Itoa(wolvespeaker) + "号狼队友发言：" + wolvespeak + "\n"
			text1 := "现在是夜晚狼人商讨时间，请根据场上局势和此前的对话内容进行你的发言以商讨杀人决策，限制在20字以内：" + "回复格式：发言：*******"
			text2 := text + text1
			response, err := talkToKimi(RoomID, text2)
			if err != nil {
				fmt.Println("Error calling API:", err)
				return ""
			}
			// 创建正则表达式，匹配“发言：”后的内容
			re := regexp.MustCompile(`发言：(.*)`)
			// 使用FindStringSubmatch方法查找匹配项
			matches := re.FindStringSubmatch(response.Choices[0].Message.Content)
			//分解
			if len(matches) > 1 {
				// matches[0]是整个匹配的字符串，matches[1]是第一个捕获组的内容
				return matches[1]
			} else {
				return "error" //此处使用error字符串标识错误
			}
		} else { //如果没有进行两的倍数次发言,则只告知，不发言
			number_of_wolves_speka[RoomID-1]++
			number_of_wolves_speka[RoomID-1] %= 3
			text := "狼人队友发言："
			text += strconv.Itoa(wolvespeaker) + "号狼队友发言：" + wolvespeak + "\n"
			text2 := text + "理解请回复：“明白。”"
			response, err := talkToKimi(RoomID, text2)
			if err != nil {
				fmt.Println("Error calling API:", err)
				return "error"
			}
			if response.Choices[0].Message.Content == "明白。" {
				return ""
			} else {
				return "error" //此处使用error字符串标识错误
			}

		} //对狼队友的发言进行回应
	}
	return "error"
} //根据type来进行处理，返回空字符串代表不发言，error代表错误

func selfDetonationInformed(RoomID int, Number int) bool {
	text := "告知其他玩家自爆信息" + strconv.Itoa(Number) + "号狼人玩家自爆出局。"
	text2 := text + "理解请回复：“明白。”"
	response, err := talkToKimi(RoomID, text2)
	if err != nil {
		fmt.Println("Error calling API:", err)
		return false
	}
	if response.Choices[0].Message.Content == "明白。" {
		return true
	} else {
		return false
	}
}

//根据输入类型来实现

//夜晚自由发言时，告知ai玩家狼人队友的发言内容，根据目前其他玩家的发言情况，ai玩家进行回复（开始时）

// func simpflyStaments( Statements map[int]string)map[int]string{
// 	text := "简化以下狼人玩家发言信息，并且以n号玩家的身份发言的格式返回：\n"
// 	for id, statement := range Statements {
// 		text += strconv.Itoa(id) + "号玩家发言：" + statement + "\n"
// 	}
// 	response, err := talkToKimi(RoomID, text2)
// 	if err != nil {
// 		fmt.Println("Error calling API:", err)
// 		return false
// 	}

// } //返回信息，简化用户发言的结果

//func gameOver
//游戏结束，删除数据库内有关这个房间的所有信息

// func WitchantidoteInformed(RoomID int, Number int) {

// } //

// func main() {
// 	ConnectDatabase()
// 	time.Sleep(2 * time.Second)

// 	gamePreparation(1, 9, 4, 3, 1, 1) // 讲诉规则
// 	time.Sleep(30 * time.Second)

// 	gameStart(1, "女巫", 1) // 分配角色和号码
// 	time.Sleep(30 * time.Second)

// 	getDarkInformed(1) // 告知黑夜
// 	time.Sleep(30 * time.Second)

// 	witchAntidote(1, 2)
// 	time.Sleep(30 * time.Second)

// 	witchPoison(1)
// 	time.Sleep(30 * time.Second)

// 	deathInformed(1, []int{2})
// 	time.Sleep(30 * time.Second)

// 	dawnInformed(1)
// 	time.Sleep(30 * time.Second)

// 	speak(1)

// }

//接受前端信息，调用kimi
